public class ReadMe {
    /**
     * 2023-2-20 计算机基础
     * 1.二进制和十进制相互转换
     *      二进制：由1和0表示
     *      十进制：0-9表示
     *      二进制转换为十进制？01001001 转换为十进制？ 73
     *      如果用73 转换为二进制怎么转换？用73除以2   01001001
     * 2.计算机配置：（Java开发常用笔记本配置（最低要求））
     *      1)处理器  CPU   i5-十代以上
     *      2）硬盘  至少512G以上  固态硬盘
     *      3）内存  16G以上
     *      ------------------
     *      假如有台式机：
     *      4）主板
     *      5）显卡：集显和独显
     *      6）机箱
     *      7）电源
     *      8）散热器
     *      9）显示器
     *      10）外设：鼠标，键盘，打印机，影响
     * 3.理解BS/CS的区别？
     *      BS通过浏览器访问
     *      CS必须安装在本地
     * 4.环境变量？意思，就是快速找到当前软件进行打开
     * 5.java 运行到虚拟机上，不是直接运行到系统
     * 6.专业文字编辑器：notepad++
     * 7.手写一个HelloWorld
     *      1：类名和文件名一致
     *      2：类名要大写（大驼峰）
     *      3：类名不要有中文或特殊字符
     * 8.java里面这里的命名规则：所有命名都不要用中文或者特殊字符
     *      1）项目名称：最好全部英文小写，如果有两个字符用-隔开
     *      2）包名：全部小写，如果有两个字符，用.隔开
     *              com.cn.wanxi.model.UserModel
     *              国际.国内.公司.模块.类
     *              所有的类不要直接命名到src下面，必须要写包
     *      3）驼峰式命名：如果多个字符，则每一个字符第一个字母大写
     *          大驼峰，则首字母大写：其他首字母大写UserModel（类名）
     *          小驼峰。则首字母小写：其他首字母大写userModel（属性，方法，变量）
     *          全大写：USER_MODEL  快捷键：ctrl+shift+U（常量）
     *          全小写：user-model（项目名）
     *          全小写：user.model（包）
     *          ----------------------------
     *          第一阶段命名规则：
     *          项目名：都是全小写
     *          class    class="user-name color"
     *----------------------------------------------------
     * 9.t odo 表示接下来要干什么事情，可以理解为任务发布，以后直接在idea里面查看即可
     *-----------------------------------------------------------
     * 10.Java 关键字，在idea里面会通过颜色进行区分，在平时不能自己用来命名
     * 11.java字符只能是单个字符a-z0-9还有一个中文和特殊字符
     * 12.java字符串用双引号括起来
     * 13.Java字面量必须要用容器来装：数据类型
     * 14.绿色的波浪线表示当前单词idea不认识，给我们一个提示，如果想让它认识？
     * 15.代码格式化对齐：ctrl+alt+l
     * 16.变量：要变化的量，就是值不固定
     *      int salary=15000;
     *      数据类型   变量名(标识符)   赋值运算符   变量值（字面量）
     * 17.标识符：用来定义名字的符号
     *      1.不能用特殊字符
     *      2.不能用Java关键字
     *      3.不能以数字开头
     *      --------------
     *      规范：以后命名全部用英文字符即可
     * 18.命名规则：
     * 19.Java数据类型
     *          基本数据类型
     *          整数:按照取值范围分类：byte  short  int  long
     *          小数：
     *          布尔
     *          字符
     *  数据类型面试一般会问：
     *          1）数据类型的字节数
     *          2）数据类型的默认值
     *          3）数据类型的大小
     *          4）布尔占几个字节?
     *    数据类型       字节数     默认值
     *    byte          1        0
     *    short         2        0
     *    int         4        0
     *    long         8        0
     *    float         4       0.0
     *    double         8        0.0
     *    boolean         1        false
     *    char         2        ‘’
     *    小数默认数据类型为double，整数默认数据类型为int
     *    对于长整型 long 命名需要大写L结尾 long l=1L;
     *    对于单精度float  用大写F结尾  float f = 1.0F;
     *    对于双精度double  用大写D结尾 double g=1.1D;
     *          引用数据类型
     * 20.键盘录入：用户想要自己添加变量的值
     *      1)需要导入第三方包  import java.util.Scanner;
     *      2）要得到工具类  创建工具类对象 Scanner scanner=new Scanner(System.in); 涉及到IO流
     *          变量命名：注意：一定不要写缩写,我们的代码是给别人维护
     *      3）得到录入的数据 int a = scanner.nextInt();
     *      注意：需要给用户提示信息
     *
     */
    /**
     * 2023-2-21 运算符
     * 回顾：
     * 1.bs/cs结构
     * 2.变量
     * 3.关键字  八大基本类型，public，class，void，static
     * 4.标识符  取的名字；
     * 5.字面量  对数据进行变量的赋值的值 一般是指等号后面的值
     * 6.键盘录入
     * ----------------------------------------------
     * 运算符
     * 当运算符进行运算时，会得到一个和当前运算符最大的运算符的数据类型
     * 如果是整数，则向下取整
     * 整数相加等于整数，如果有字符相加，则叫字符串拼接
     * 字符串拼接从左到右开始计算，
     * --------------------------
     * 自增自减运算符
     * a = a++;  先将右边的a的值赋值给左边的a，
     *           然后对右边的a进行++，
     *           并没有将值赋值给左边的a
     * a=a--;和上面一样
     * b=++b;   先将右边的b进行加1，然后赋值给左边的b，所以左边的b加1
     * ----------------------------------------------------
     * 数据类型转换
     *      隐式转换，将范围大的装入范围小的，省略了（数据类型）
     *      强制转换，将范围小的赋值给范围大的，必须显式（数据类型）
     *      java里面没有非零表示true，零表示false的说法
     * --------------------------------------------------
     * 赋值运算符
     * b+=1;//隐藏了一个强制转换其实意思就是b=b+1;
     * 只不过做了一个强制转换b=(byte)(b+1);
     * ---------------------------------------------------
     * 关系运算符
     * 比较运算符
     * 关系运算符一般用于基本数据类型
     * ------------------------------
     * 逻辑关系
     * &   true&false    false  遇false为false
     * |    遇true为true 只要有一个为true，则结果为true
     * ！  取反
     * ^   true^false  相同为false，不同为true
     * 短路运算符
     * &&  false  && false    遇false则后边条件不进行计算
     * ||
     * 短路与只要左边false，则右边不运行
     * 短路或，则只要左边为true，右边不运行
     * ---------------------------
     * 三运运算符
     * int a=b>c?e:f;
     * 如果b>c为true，则a的值为e，否则为f；
     * ----------------------------------------
     * 优先级
     * 一般情况下，先乘除后加减，先括号，后外边，先短路与在短路或
     *
     *
     */
    /**
     * 2023-2-22 分支与循环
     * 1.包的层数最好不要超过四层  com.cn.wanxi.service.impl
     *      com.wanxi.service.impl
     * 2.F9  跳转到下一个断点，如果没有断点，则直接结束程序
     *      Process finished with exit code 0
     * 3. System.exit(0);//Java虚拟机结束 手动结束程序
     * 4.习惯每写一句代码都按快捷键 自动对齐  ctrl+alt+l
     * 5.做任何一个文档，习惯性 ctrl+s
     * 6.程序里面最好不要出现固定的数值：把固定的数值称为魔法值，所以应该用变量
     * 7.switch  () 表达式只能是byte，short，int，char，enum，String
     *      注意：case  必须是常量不能是变量，case 的值必须唯一，不能重复
     * 8.for 循环中如果定义变量，则每次循环都会在内存中释放，表示下一次执行时，会是默认值
     * 9.只要定义变量，都会在内存里面开辟一个空间，用来存储变量的值
     * 10.无论if还是for循环，如果里面只有一条执行语句，则可以省略大括号，但是，建议都写上
     * 11.do.. while至少执行一次循环体
     * 12.break;很多时候，在循环中，不需要执行太多的语句，则会在某个条件满足后直接跳出循环
     * 13.continue;//跳过当次循环，直接执行下一次循环
     * 14.如果满足某个条件，后面的事情都不做了，则用return，跳出当前方法
     * 15.如果满足某个条件，跳出所有方法：System.exit(0);
     */
    /**
     * 2023-2-23 数组和二维数组
     * 1.类的编译过程
     *      1）创建一个类的Java文件  MyTest.java 源文件
     *      2）编译源文件  MyTest.class  字节码文件
     *      3）运行MyTest.class 加载字节码文件 通过类模板进行加载
     *      4）加载到内存后，由虚拟机JVM开辟一个空间
     *      5）这个空间分为三部分  栈  堆  常量区
     *      6）栈一般存放地址  基本数据类型
     *      7）堆一般存入new的对象：通过new关键字创建的对象
     *      8）常量区 一般存固定的值:方法和类:
     * --------------------------------------------
     * 2.静态定义数组 规范：int[] array1；
     * 3.以后只要是数组，第一想到的就是遍历：循环
     *          for (int i = 0; i < array1.length; i++) {
     *             System.out.println(array1[i]);
     *         }
     *         得到里面的数据用:array[i];
     *         数组的第一个数用0表示，
     *         数组的索引从0开始
     *         数组的长度array.length
     *         数组的长度是length属性还是length方法？  属性
     *         String的长度是length属性还是length方法？  方法
     * 4.字符串拼接,打印数组
     * 5.如果每次new的对象都是一样的，可以将new对象的代码放到for循环外面
     *    如果每次都需要不同的new对象，则只能写在for循环里面
     * 6.动态数组：在不知道具体数据，只知道数组大小的时候用
     * 7.静态数组：在知道具体数据，直接使用
     * 8.随机数
     *      随机数  在[m,n]之间的随机数
     *      random.nextInt(n-m) + m
     * 9.数组下标越界
     * 10.空指针异常
     * 11.数组：取值，赋值（覆盖以前的值）：循环和遍历，索引和长度
     * -------------------------------------------------
     * 12.二维数组是对一维数组的再次封装,
     *      将相同数据类型的一维数组装入到一个容器就是二维数组
     *      里面的一维数组的长度可以不一样
     * 13.int[][] arr=new int[i][j];
     *      i表示二维数组arr里面的长度的索引
     *      j表示一维数组的索引
     * 14.理解数组和二维数组在内存中的展示
     *
     */
    /**
     * 2023-2-24 方法
     * 1.数据类型转换
     *      范围之间转换
     *      小范围赋值给大范围   强制转换 int a; byte b=(byte)a;
     *      大范围赋值给小范围   隐式转换 byte b; int a=(int)b;
     *      隐式转换可以写（int）b；只不过可以省略
     *      隐式的强制转换   byte b+=1; b=(byte)(b+1);
     * 2.数组
     *      对数组的增删改查
     *      曾 ：对数组进行创建 int [] arr={};简写
     *          int [] arr=new int[]{};
     *          int [] arr=new int[5];//只定义数组的长度
     *      删除：没有删除
     *      改：覆盖   arr[0]=1;
     *      查询：遍历循环
     *      -------------------------
     *      一想到数组，就会想到遍历
     *      for(int i=0;i<arr.length;i++){
     *          // i一定是小于arr.length，不能等于
     *         System.out.println(arr[i])//如果等于length就会报数组下标越界
     *         arr=null;
     *         arr[i]// 空指针异常
     *      }
     * 3.二维数组：
     *     double[]   []  array={};
     * 4.Arrays.toString(array[i])将数组打印成字符串
     * -------------------------------------------------------------
     * 方法：
     * 1.方法的作用：提高复用性
     * 2.方法的定义：
     *      一个完整的方法定义
     *      权限修饰符   特征修饰符  返回值类型  方法名(参数数据类型  参数名...) 异常{
     *          执行体
     *          return  返回值
     *      }
     * 3.方法的规则：
     *      1）如果一个方法里面做的功能太多
     *      2）方法里面的代码太多（一般情况下代码超过80行就要考虑写方法）
     *      3）按照面向对象的的规则：各做各的事情，互不影响
     * 4.只要由static修饰的方法，里面要去调用其他方法或者其他变量，也必须用static修饰
     * 5.方法名定义：见名知意
     *      1）不能随便命名  aa  a1  1a;
     *      2)不能写缩写   findById()   fbi();
     * 6.方法的目的：就是为了灵活使用：方法里面不应该存在固定的数值
     * 7.如果由多个类都会用到同一个方法，则会将当前的方法封装到一个工具类里面
     * 8.import是导入其他包里面的类
     * 9.全限定符  com.wanxi.util.Tool  包名+类名
     * 10.String str="";定义一个字符串
     * 11.如果方法有返回值，则将方法里面的void修改为返回值的数据类型
     * 12.方法里面的void表示没有返回值
     * 13.方法上面的参数叫做形参，调用方法时传递的参数叫做实参
     *      printTimes(times);实参
     *       private static void printTimes(int times) 形参
     * 14.以后定义方法的时候，最好都写一个返回值：
     * 15.对于方法名和参数不同的方法，如果功能差不多，
     *      可以写一个方法名，只要参数数据类型和个数不一样即可
     *      因为Java虚拟机会根据不同的参数类型和个数调用不同的方法
     * 16.重载：
     *      1）功能相同
     *      2）参数类型不同
     *      3）参数个数不同
     *      4）同一个类中（可以是父类和子类）
     * 17.任务：
     *      1）把ppt上面的代码都敲一遍
     *      2）将练习题做完
     *      3）知道每一行代码意思
     *      4）知道为什么这么提方法
     */
    /**
     * 2023-2-27 案例
     * 1.方法：目的，就是为了代码能够复用，避免代码臃肿
     * 2.如果一个方法里面做了很多种事情，则需要将代码按照功能模块分开，最好一个方法里面做一件事情
     * 3.方法里面两个地方：
     *          1）参数
     *          2）返回值
     *    -------------------------------------------
     *    实参：实际的参数：具体的值
     *    形参：在方法里面，有数据类型参与，没有具体的值
     * 4.面试？Java里面是否有值传递和引用传递？
     *      引用类型：传递的是地址：不是复制值（传递的是地址的值）
     *      基本类型：传递的是值：复制的变量的值
     *      Java里面没有引用传递：传递的是地址的值
     */
    /**
     * 2023-2-28 面向对象基础
     * 1.将案例里面的代码不用看录屏都能自己写出来
     * 2.能够理解怎么写方法？为什么要单独列一个方法
     * ----------------------------
     * 1.一个类里面有一个main方法：如果所有的代码写在一个方法里面
     * 2.需要将不同的代码按照功能模块进行提取：方法？
     * 3.如果每个方法做的事情不一样，但是又和其他方法没有任何关系，可能还是属于不同的主体
     * 4.那么就要考虑将不同的方法放入不同的类里面：按照主体（对象）
     * 5.面向对象编程，就是将代码按照有多少个对象进行编写：
     *      1每一个对象写一个类，
     *      2而且类里面的方法只能跟自己相关，
     *      3不能跟别人有联系（不能又太大的练习）
     * 6.类是一个不具体的，是抽象的，对象一般指具体的，
     *      可以理解为对象是对类的具体化，类是对对象的抽象化
     *      一个人叫做对象，一些人叫做人类
     * 7.类 一般分为 属性和行为
     *      属性  变量
     *      行为  方法
     *      方法里面的变量叫做局部变量
     *      方法里面不能调用其他方法里面的变量，只能调用当前类的变量
     * 8.普通方法没有static关键字，普通属性没有static修饰，叫做成员变量
     * 9.有static修饰的方法叫做静态方法，有static修饰的性属叫做类变量，静态变量
     * 10.有static修饰的属性或者方法，在内存里面只开辟一次空间
     * 11.有static修饰的属性或者方法，调用的时候用类.方法或者类.属性名称
     * 12.普通属性和方法调用，用对象.属性名，对象.方法名
     * 13.有static修饰的属性或者方法在内存里面只开劈一次空间，可以进行数据共享
     * ----------------------------------------------------------------
     * 14.基本数据类型都有对应的包装类（引用数据类型）
     *      byte        Byte
     *      short       Short
     *      int         Integer
     *      long        Long
     *      float       Float
     *      double      Double
     *      boolean     Boolean
     *      char        Character
     *      ---------------------------
     *      基本类型一般用于计算：
     *      引用类型：功能强大一点
     *      -------------------------
     *      拆箱和装箱
     *      将基本类型转换为引用类型叫做装箱 Integer i=1;
     *      将引用类型转换为基本类型叫做拆箱  int i=Integer.parseInt("1");
     * 15.this指的是对象地址，谁调用就是谁的地址
     * 16.构造方法不能手动调用。
     * 17.构造方法和类名一致，不写返回值数据类型和返回值和return
     * 18.类里面默认一个无参数的构造方法
     * 19.如果定义一个有参数的构造方法，则以前默认无参数的构造方法失效 ，需要手动写上
     * 20.打印一个对象，则直接打印地址，如果想要打印出来，则需要将对象转换为字符串
     * 21.如果有toString方法，则子类会覆盖父类的方法
     * -------------------------------------------------------------
     * 知识点回顾：
     * 1：面需对象思想
     * 2：属性和方法：变量和行为
     * 3：static的用法
     * 4：this
     * 5：内存图
     * --------------------------------------------------
     * 面试题：面需对象的三大特征？封装，继承，多态；抽象
     * 1.public  暴露公共的访问接口，当前项目谁都可以访问：访问之前需要导入类的包
     * 2.对数进行封装  dao
     * 3.对对象进行封装  model
     * 4.如果不想让其他类调用，则用私有的关键字 private
     * 5.权限修饰符：访问修饰符
     *      public   公共的    所有类都可以调用
     *      private  私有的    当前类可以调用
     *      protected 受保护   一般用于子类
     *      默认不写  默认不写   当前包可以使用
     * ------------------------------------------
     * 6.一个完整的JavaBean
     *      1.属性私有
     *      2.构造方法：全参，无参
     *      3.set/get方法
     *      --------------------
     *      model 实体类
     *      entity  实体类
     *      vo   view Object  视图对象
     *      dto  data translation  Object  数据传输对象
     *      do   数据对象
     *      pojo  是对所有对象的统称
     * -------------------------------------------------
     * 封装：
     *      隐藏细节
     *      暴露公共的接口
     *      ----------------------
     *      属性隐藏，暴露调用方式
     * 7.引用类型都默认有一个toString方法，如果对自己重新写了一个toString方法，则覆盖父类的toString方法
     * 8.所有引用类型都有一个父类叫做Object
     * 9.将第一阶段的项目对象抽取出来，写出完整的Javabean对象
     * 10：餐饮项目里面有哪些对象？将自己作为用户，哪些文字或者图片是需要修改的
     *      公司对象
     *      导航
     *      新闻
     *      新闻类型
     *      产品
     *      产品类型（六大菜系）
     *      留言
     *
     */
    /**
     * 2023-3-1 字符串
     * 1.构造方法：得到对象，对对象里面的属性进行赋值
     * 2.对对象进行封装：隐藏不需要展示的细节，
     *      private私有的方式，
     *      如果想要提供给别人访问的接口，用public
     *-----------------------------------------
     * 3.类的组成部分
     *      1）包
     *      2）类名
     *      3）属性
     *      4）方法
     *      5）构造方法
     * 4.java.lang  不需要引入,直接用即可
     * 5.字符串不可变，它们的值在创建后不能被更改
     * 6.字符串其实是一个字符数组，既然是数组，那么长度不能改，
     * 7.final 表示最终的，不可改变的，String被final修饰，表示值不能被改变
     * 8.定义字符串建议用： String s3 = "aaaa";
     * 9.基本数据类型进行比较用==。比较的是值
     * 10.引用类型进行比较用==，比较的是地址
     * 11.String s=new String("a");创建了几个对象？
     * 12.String s5 = "a" + "b" + "c"; 先做运算，在执行
     * 13.static的目的就是为了共享数据，
     *      只要执行了以后，就会在内存里面开辟空间，只要项目一致运行，则一直存在
     *      而很多时候不需要一直运行，所以可以考虑不用static
     * 14.将字符串转换为字符数组 ：char[] chars = str.toCharArray();
     * 15.既然字符串是一个字符数组，能不能直接通过索引拿到对应的字符 char c = str.charAt(2);
     * 16.String 每一次赋值都会重新创建对象，除非方法区已经有的字符不用创建
     * 17.所以，以后用到字符串拼接的时候，用StringBuilder，可以理解为创建一个对象后，自动扩容
     * 18.StringBuffer和StringBuilder用法都一样，只不过以后的应用场景不一样？
     * 19.String和StringBuffer和StringBuilder之间的区别？
     * 20.字符串截取部分字符
     *      substring(start, end);截取索引在[start,end)之间的字符
     *      substring(start);截取索引在start后面的所有字符（包括start）
     * 21.字符替换：phone.replace("*","&");   将*换成&
     *      replace(old,new)；
     * 任务：有一堆敏感词汇，怎么替换成*，注意*的个数和敏感词汇的个数一直？
     * 22.创建对象的时候，数据类型不要出现基本类型，全部用包装类
     * 23.split 字符串强制转换为字符数组
     * 24.学会字符串和整形进行相互转换
     * ----------------------------------------------------
     * length()
     * charAt(index)
     * toCharArray()
     * substring()
     * replace()
     * split
     * equals()
     * ---------
     * contain()
     * startWith
     * indexOf(char)通过字符，找到字符对应的索引
     * trim() 去掉字符串两端的空白字符  " a a a   "
     * isEmpty()判断是否为空字符
     */
    /**
     * 2023-3-2 集合基础
     * 1.String 常用方法的理解
     *      1）长度  length();方法
     *      2）split   将字符串根据某种字符（分隔符）进行分割成字符串数组
     *      3）substring  截取字符串
     *      4）replace  替换字符串
     *      5）判断是否非空  "".equals(str) 后面还会学习另一个包，判断是否为空StringUtils
     * 2.JavaBean
     *      1）定义私有属性
     *      2）构造方法
     *      3）设置set和get方法
     *      4）引入第三方jar包  Lombok
     * ----------------------------------------------------
     * 3.如果已经对数组的数据已经满了，如果还要增加数据，则需要对数组进行扩容
     * 4.数组不能更改长度，如果要添加新数据很麻烦
     * 5.那么有没有一个更好的方法，可以自动扩容
     * 6.任务：写一个MyArray.java 里面包含自动扩容的一个方法？
     * 7.集合就是对数组的自动扩容：集合就是对数组的封装
     * 8.ArrayList<E> 这个E固定了当前集合的数据类型:E表示泛型,数据类型必须是引用类型
     * 9.删除集合里面的元素，可以用索引，也可以用对象，对象不能直接new，只能通过变量
     * 10.集合主要的内容：增加，修改，删除，查询
     * 11.数组：增加，修改，查询，无法做到删除和扩容
     * 12.foreach循环，一般用于遍历
     *      for(数据类型 变量名：集合){// 冒号左边的是集合的元素，冒号右边的就是需要遍历的集合
     *
     *      }
     * 13.集合至少用for循环不能删除，因为删除一个，长度就会变小
     * 14.删除对象（过滤）用removeIf
     * 15.学生管理系统
     *      1）定义一个集合，用于存学生对象
     *      2）所有的增删查改不能写在一个方法里面，应该单独写方法
     *      3）要做一个死循环遍历
     *      4）对于操作完后需要给用户提示
     *      5)修改list需要index索引，能不能用foreach来做？
     */
    /**
     * 2023-3-3 面向对象之继承
     * 1.类的定义
     *      类的组成部分？包，类名，属性，方法，构造方法
     *      命名规范：
     *      包：全小写
     *      类名：大驼峰
     *      属性，方法都是小驼峰
     *      构造方法和类名一致：构造方法分为无参和有参数
     * 2.对象的使用 ：通过构造方法得到对象，对象里面的属性和方法可以通过对象直接调用
     * 3.private  私有，就是其他类不能调用被private修饰的属性或者方法
     * 4.this   代表对象，当前对象，谁调用就代表谁：
     *          this只能调用当前对象的属性和方法吗？
     *          this调用属性，首先在当前类里面找，如果本类找不到，则去父类，超类里面找，
     * 5.封装：隐藏细节，暴露接口
     * 6.构造方法：任何一个类默认一个无参数的构造方法
     *          如果手写了一个有参数的构造方法，则默认的无参数构造方法失效
     *          需要手动写一个无参数的构造方法
     *          构造方法是有返回值，不写返回值类型和return
     * 7.JavaBean  ：
     *          1.属性私有
     *          2.set/get方法
     *          3.构造方法
     *          @Data//设置set和get方法和toString方法
     *          @NoArgsConstructor//无参数的构造方法
     *          @AllArgsConstructor//全参数的构造方法
     * 8.Scanner  获取用户输入
     * 9.Random   随机数，m,n之间的随机数
     * 10.String  常用方法
     * 11.基本类型和包装类：数据转换：隐式和强制转换，向上转型和向下转型
     *      装箱和拆箱：
     * ------------------------------------------
     * 1.以前如果类里面有很多一致的代码，考虑将代码提取到工具类，这个工具类和当前类的关系不大
     * 2.如果提取的代码和当前类的代码关系大，或者具有组合或聚合关系
     * 3.如果子类继承父类，子类可以直接调用父类的方法，但是，不能调用私有方法
     * 4.子类可以调用父类的protected受保护的：修饰的 属性或者方法
     * 5.如果子类和父类的方法一致，则调用子类的方法时，则执行子类的方法
     * 6.子类和父类方法一致，其实是对父类的方法进行重写（覆盖）
     * 7.重写：子类扩展了父类的相同方法
     *      1：方法名相同
     *      2：个数必须相同
     *      3：参数类型是否相同？必须
     *      4：和返回值数据类型是否相关？可以不一致，但是子类必须小于等于父类
     *      5.权限修饰符，子类必须大于等于父类
     *      一般判断两个方法是否重写用注解@Override
     *      简单理解重写：父类和子类方法一样
     * 8.重载：
     *      1：方法名相同
     *      2：参数类型和个数不同
     *      3：和返回值类型无关
     *      -----------------
     *      重载，不局限于同一个类
     * 9.权限修饰符：四个，可不可以修饰类？
     *      类只能是默认不写和public修饰:
     *      创建类的主要目的？为了创建对象，让别人调用
     * 10.基类，直接父类，超类，超越父类的类
     * 11.Object,所有类的父类或者超类,最顶端的类，所有引用类型默认继承Object类
     * 12.面试会问？Object的常用方法？
     *      1：getClass() 用于反射，得到当前类
     *      2：hashCode() 打印地址
     *      3：equals() 判断地址值是否相等
     *      4：clone() 克隆，拷贝，浅拷贝和深拷贝
     *      5：toString() 将对象转换为字符串，所有对象默认都是toString
     *      6：notify() 唤醒线程  notifyAll()唤醒所有线程
     *      7：wait() 线程等待
     *      8：finalize() 垃圾回收的时候会用
     * 13.以后写代码尽量：解耦：不要有太强的耦合性
     * 14.变量的访问：局部变量--》成员变量--》父类--》超类 ：就近原则
     * 15.this()只能在构造方法里面调用，而且放在第一行
     * 16.子类的构造方法(无论是否有参数)默认写了一个无参数的父类的构造方法：super();
     * 17.java中是否支持多继承，支持，接口可以支持
     * 18.Java接口是属于类吗？属于类
     * 19.Java接口是对抽象类的封装,抽象类是属于类
     * 20.Java普通类不能支持多继承，只有接口才支持
     * ------------------------------------------
     * 修饰符：
     * 权限修饰符  访问修饰符
     *  public  所有类都可以访问
     *  private 只能当前类可以访问
     *  protected  一般用于子类访问父类
     *  默认不写  当前包可以访问
     * 状态修饰符  非访问修饰符  特征修饰符
     * final  关键字  最终的
     *      修饰方法：方法不能被重写:如果父类不想子类重写（修改）方法，则用final修饰
     *      修饰变量：表示是常量，不能再次赋值:定义变量的时候，一定要赋一个初始值，
     *              常量，只能使用，不能再次赋值
     *      修饰类：不能被继承,不能有子类继承，但可以作为其他类的子类
     *      如果final修饰的是引用类型：则不能改变当前的引用地址，可以改变里面的内容
     * static 静态：简单理解为数据共享
     * 静态方法里面不能直接调用非静态属性或方法,只能通过对象.属性，对象.方法名
     * 普通方法可以调用静态方法和非静态方法
     * 21.static一般用于工具类
     *      一般构造方法需要私有：
     *      私有后就不会被别人创建多个对象，占用内存空间
     *      成员变量和方法都用static修饰即可
     * 22.代码块在创建对象时，执行
     * 23.静态代码块在编译代码时执行，静态代码块只要用到了类，就会执行，
     *      代码块只能创建对象调用构造方法时才执行
     *      代码块在构造方法之前执行
     *      静态代码块先于代码块执行
     *      代码块先于构造方法执行
     *--------------------------------------
     * 知识点：
     * 1.理解继承
     * 2.理解final和static
     * 3.math和代码块
     * 4.掌握。代码的执行顺序
     *
     */
    /**
     * 2023-3-6 面向对象之多态和抽象
     * 1.首先，如果有多个对象，他们之间有相同的属性或者方法，就考虑抽象出一个父类
     * 2.父类的特征一定是子类必须拥有
     * 3.子类和父类的代码合并到一起才能构成一个完整的类：这里就用继承
     * 4.继承就是子类是父类的东西A is a B；
     * ------------------------------------------
     * 多态：
     * 1.父类和子类都不需要写run方法
     * 2.父类和子类都自由自己的属性和方法：一个Javabean对象
     * 3.将要操作的run方法写到另一个类ParentAnimal里面，
     *      里面的方法用父类作为参数进行编写public void run(Animal animal)
     * 4.在执行类里面，将子类传递到方法里面
     *      ParentAnimal parentAnimal = new ParentAnimal();
     *         parentAnimal.run(cat);
     * 5.如果是继承：Animal cat = new Cat("cat");
     *      System.out.println(cat.age);
     *      如果是属性，则调用属性的时候只能调用到父类的属性
     *      cat.run();
     *      如果是方法，则调用的是子类的方法，因为有重写
     * 6.向上转型：将范围小的转换为范围大的，byte--->int
     *      byte b=1;
     *      int a=1;
     *      a=b;
     * 7.向下转型：将范围大的赋值给范围小的  int-->byte
     * 8.如果方法没有方法体，则方法必须写成抽象方法public abstract void run();
     * 9.如果类里面有抽象方法，则类必须是抽象类public abstract class Animal
     * 10.如果是抽象类，则里面的方法一定是抽象方法吗？不一定
     * 11.抽象类的命名规则，一般在类前面加abstract
     * 12.抽象类可以实例化，
     *    只不过，实例化的时候，默认创建了一个子类，
     *    子类必须实现里面的所有抽象方法
     * 13.请问子类必须重写抽象类里面的抽象方法吗？不一定
     * 14.如果子类也是抽象类，则可以不用实现里面的抽象方法
     * 15.接口是抽象类的一个特殊类
     * 16.常量的命名规则：private static final String SEX="男";
     *      static 数据共享
     *      final  数据不能被修改
     *      SEX   常量的标识符全部大写，如果多个单词则用下划线，USER_SEX
     * 17.抽象类的主要目的：要求子类必须重写它的抽象方法
     * -------------------------------------------------------
     * 知识点：
     * 1.多态
     *      有继承关系：父类和子类的关系
     *      有重写
     *      父类引用指向子类
     * 2.抽象
     *      子类要重写父类的方法，说明父类方法没有用，则不需要写，可以写成抽象方法
     *      子类必须重写父类的抽象方法
     */
    /**
     * 2023-3-7 面向对象之接口和lambda表达式
     * 1.接口默认的修饰符是什么？ public abstract
     * 2.一般情况下，如果抽象类里面都是抽象方法，那么将抽象类改为接口
     * 3.接口是抽象类的一种表现形式，是属于特殊的抽象类
     * 4.接口里面可以有变量：为常量：public static final String NAME = null;
     * 5.一般情况下，固定的变量，不允许出现在普通类里面，出现在这里叫做魔法值
     * 6.一般类里面不允许出现魔法值：那么这些变量应该放到哪个地方？
     * 7.如果里面都是常量，则将常量放大枚举,枚举就是一一列举
     * 8.一般抽象类如果全是常量，则用枚举，如果全是抽象方法，则用接口
     * 9.枚举得到值，定义一个变量，设置set/get方法，创建构造方法
     * 10.以后尽量不使用或者禁止使用枚举
     * 11.普通类需要实现接口里面的所有抽象方法
     * 12.以后，大多数场景下，接口里面一般只有一个抽象方法
     * 13.如果抽象类里面有普通变量，设置了全参的构造方法，那么子类也需要定义全参构造方法
     * ---------------------------------------------------------------------
     * 14.接口目的：就是对行为的抽象，是一个特殊的抽象类
     * 15.抽象类可以理解为由三大部分组成：普通类，枚举，接口
     * 16.内部类：在一个类里面创建另一个类
     * 17.内部类可以直接使用外部类的成员和方法，内部类可以理解为和外部类成员级别一致
     * 18.外部类访问内部类需要创建对象
     * 19.无论内部类和代码块都是需要取执行代码，只不过内部类可以进行调用
     * 20.内部类的主要目的：就是为了创建属于自己的对象，为了不让别人直接调用,他是属于自己的外部类
     * 21.内部类可以理解为，外部类的一部分，是一个组合的关系，一般情况下是不可分割的；
     * 22.类和类之间的关系？
     *      1：继承/实现  子类和父类的关系
     *      2：依赖   将类作为参数进行传递 class Dog{ run（Animal animal）;}
     *      3：组合   可以理解为很多个类，是另外一个类的组成部分：不可分割的，也可以理解为私有的内部类
     *      4：聚合   可以理解为很多个类，只不过是可以分割的；
     * -------------------------------------------------------------
     * lambda表达式
     * 23.如果要对接口或者抽象类进行实例化，则会创建一个类,这个内叫做匿名局部内部类
     * 24.像这种类，一般可以简写：lambda表达式：()->执行体
     * 25.什么情况下不用写大括号？if，else，for等如果后面只有一行代码，则可以省略大括号
     * 26.如果参数只有一个，则可以省略小括号
     * 27.如果参数只有一个，则可以省略数据类型，如果由多个，要么都省了数据类型，要么都写上
     * 28.lambda表达式：接口，而且只能有一个抽象方法
     * 29.lambda表达式一般在JKD自带的代码里面有，以后自己封装的时候可以写lambda表达式
     *
     *
     */
    /**
     * 2023-3-8 常用API
     * 1.接口的主要目的就是扩展，扩展就是给别人调用，一般修饰符都是public
     * 2.lambda表达式：可以理解为一个特殊的接口，只有一个抽象方法
     * 3.以后接口最好的方式，每一个接口做一个抽象方法，只要关系不大就不要放在一个接口里面
     * -----------------------------------------------------
     * 4.没有构造方法，如何访问类中的成员？
     *      有可能类在不同的包，不同的项目：需要引入包
     *      1.权限修饰符用public，访问修饰符
     *      2.特性修饰符static非访问修饰符：共享数据 final  属性：常量，方法：不能重写，类不能被继承
     * 5.创建类的时候，类名和引用的类名一致？命名的时候，最好不要和jdk自带的名字一致
     *      如果非要和jdk的类名一致，那么最好在不同的包里面
     * 6.一般情况下，自己写工具类的时候，用静态方法或者变量
     *      静态变量：常量；作为变量时，static和final是一起，
     *      常量的主要目的：为了配置数据
     * 7.this(),super()只能放在构造方法的第一行
     * 8.Object和Objects有什么区别？
     * 9.BigDecimal  一般小数用，精度比float和double更高，
     * 10.new BigDecimal（）；里面的参数建议用String，精度更高，不要用double
     * 11.以后金钱等小数用BigDecimal
     * 12.基本数据类型运算是包装类转换为基本数据类型
     * 13.以后只要是引用数据类型都需要做非空判断
     * 14.所有的包装类都有valueOf方法
     *
     */
    /**
     * 2023-3-9 异常和日期
     * 1.异常：不正常，编译不成功，或者执行有问题
     * 2.数组下标越界  ArrayIndexOutOfException;
     * 3.空指针异常  NullPointException;
     * 4.数字转换异常  NumberFormatException;
     * 5.异常分为运行时异常和编译时异常
     * 6.编译时异常，直接编译不成功，和代码错误表现是一样，
     *      代码错误idea不能解决
     *      编译错误idea可以通过代码解决：抛出异常
     * 7.如果执行代码时，出现异常，觉得后面的代码执行无意义，则直接抛出异常
     * 8.执行代码时，出现异常，如果后面的代码需要执行，则用try catch
     * 9.以后出现异常都需要对异常进行保存：日志处理
     * 10.以后如果一段代码会有几个异常，则每个异常应该单独写一个try catch
     * 11.理解代码错误，编译时异常，运行时异常
     * 12.代码错误无法通过代码进行补救
     *      编译时异常可以在方法后面抛出异常（必须）
     *      运行时错误，也可以抛出异常（非必须）
     * 13.如果用抛出异常，没有捕获，则一直会跑到JVM去，由Java虚拟机去执行异常
     * 14.所以，以后一般情况下建议用try catch，什么地方出现异常什么地方进行捕获
     * 15.除非后面的代码没有意义，则用抛出，否则用try catch
     * 16.try catch里面finally是否一直会执行？ 不一定
     * 17.try catch里面finally是否一直会执行？finally里面的代码是在try里面的return之前执行还是之后执行？之前执行
     * 18.try catch里面finally是否一直会执行？什么情况下不会执行?
     * -----------------------------
     * 19.日期取得毫秒数和设置日期：都是通过毫秒数
     * 20.将毫秒数（日期）转换为看得懂的年月日时分秒
     * 21.以后，注意将不同的代码写入不同的方法
     * 22.注意多写注释
     * 23.时间格式化用的最多：SimpleDateFormat
     */
    /**
     * 2023-3-10 集合list
     * 1.集合就是一个可动态扩容的数组，是对数组的封装
     * 2.List<Object> 泛型，主要是规定集合的数据类型
     * 3.Collection 没有get方法，不能用for和while进行遍历，可以用forEach
     * 4.集合删除最好用迭代器Iterator
     * 5.Collection没有set和get方法
     * 数据结构：
     * 6.栈 ：先进后出
     * 7.队列： 先进先出  管子 左右相通
     * 8.泛型可以理解为Object，因为Object是所有类的父类，泛型就是将子类进行统一处理
     * 9.很多时候就想要类型为Integer，但是有时候还可以是其他数据类型，是不是要重新写一个方法？
     * 10.泛型不需要大家理解太深，能够调用别人的接口即可，如果能自己写更好,在能够自己做架构的时候需要自己写
     * 11.泛型：List<? extends Number>  extends 左边的是子类
     *      List<? super Number>  super 左边的是父类
     * 12:今日知识点：
     *      1）collection  增加，遍历，删除   迭代器
     *      2）collection  没有set和get方法
     *      3）List  增删改查
     *      4）ArrayList
     *      5）LinkedList  增加 first和last
     *      6）数据结构
     *          栈
     *          队列
     *          链表
     *          数组
     *      7）泛型了解
     */
    /**
     * 2023-3-13 集合set
     * 1.set可以去掉重复,存的是第一个相同的元素
     * 2.set存的时候进行了排序
     * 3.public int compareTo(Object o) {
     *         return 0;
     *     } return 0；表示两个对象相同，如果不为0，非零表示不同
     * 4.如果要创建Set里面如果是对象，则要实现Comparable<Student>重写里面的compareTo方法
     * 5.里面方法要自己定义规则
     * 6.以后代码里面不允许出现else，到学会架构的时候，不允许出现if else；包括switch
     * 7.自然排序，实现接口
     * 8.比较器排序，就是利用构造方法，带参数实现里面的public int compare(Student o1, Student o2)
     * 9.
     */
    /**
     * 2023-3-14 集合map和stream流
     * 1.set  二叉树--》搜索树排序树查找树---》平衡树---》红黑树
     * 2.set 进行遍历（同list差不多，只不过不能用索引）
     * 3.set存入相同的值时，后面的存不进去
     * 4.map存入相同的值时，后面的覆盖前面的值
     * 5.map遍历
     *      1）去掉里面所有的key（map.keySet()），然后进行遍历
     *      2） Set<Map.Entry<Husband, Wife>> sets = map.entrySet();
     * 6.TreeMap排序规则也需要自己定义：自然排序和比较器排序
     * 7.getOrDefault（key,默认值）;如果能够拿到，则直接取得自己的值，如果拿不到，则取默认值
     * 8.不定长的数组： public static void add(int... arr)
     * 9.可变参数
     * 10.不可变集合(了解)
     * 11.stream可以再次进行过滤
     */
    /**
     * 2023-3-15 file类
     * 1.内存里面的数据不能持久化：不能永久保存
     * 2.数据永远首先进入内存：读取操作
     * 3.将内存的数据放入硬盘，叫做保存
     * 4.将硬盘的数据读取到内存，读取
     * 5.如果自己取存一个文件，你们Java代码的思路是什么？
     *      面向对象编程：
     *      1）创建对象
     *      2）操作类
     * 6.Java 有没有自己的API已经做了这个事情？如果有，则直接调用，没有，则自己写
     * 7.类的组成部分？类名，属性，方法，包，构造方法
     *      File类：
     * 8.文件夹是否占用硬盘大小？文件是否占用硬盘大小？
     * 9.dir.mkdir();//创建单个文件夹,如果父目录不存在，则创建不成功
     *   dir.mkdirs();//创建多个文件夹,就算父目录不存在，将父目录和自己的文件夹同时创建
     * 10.java里面如果直接在split里面写.，则需要用转义字符name.split("\\.");
     * ------------------------------------------------------
     * 知识点总结：
     * 1.创建文件或者文件夹前提条件：路径（相对路径或者绝对路径）File file=new File(path);
     * 2.判断当前文件或者文件夹是否存在 exists()
     * 3.判断是否为文件或者文件夹 isFile(),isDirectory()
     * 4.mkdir();mkdirs();
     * 5.createFile();
     * 6.delete  递归
     * 7.File[] files = file.listFiles();
     * 8.getName
     * 9.split("\\.");字符    转义
     * 10.java字符转义  换行：\n 换行 \t 制表键 \r按enter键
     * 11.Java 字符占用多少个字节？有可能1，2，3，4个字节？
     */
    /**
     * 2023-3-16 IO流
     * 1.File 输入输出：将内存里面的数据保存到硬盘，硬盘里面的数据读取到内存
     * 2.创建文件或者文件夹：有路径，判断是否正确？创建文件夹，mkdirs，createFile
     * 3.删除文件或者文件夹：递归
     * 4.能够对文件或者文件夹进行分类
     * ---------------------------------------------
     * 5.一般工具类最好用静态，不要用创建对象实例化去得到对象
     * 6.字符转换为字节数组才能存入
     * 7.一个字符占多少个字节
     *      1）1个字节  gb2312
     *      2）2个字节  GBK
     *      3）3个字节  UTF-8
     *      4）4个字节  16进制
     * 8.复制文件：其实就算读取源文件，然后写入一个新文件：最好用字节流
     * 9.字节流写入中文或者读取中文的时候一般会出现乱码，因为一个中文占用几个字节
     * 10.读取纯文本用字符流：Reader reader = new FileReader(oldPath);
     * 11.对于写字符流Writer writer = new FileWriter(file);需要刷新或者关系
     * 12.建议以后手动去关闭流
     * --------------------------------------
     * 任务：
     * 1.复制文件
     * 2.剪切文件
     * 3.删除文件
     */
    /**
     * 2023-3-17 反射枚举
     * 1.io流的分类：
     *      按照流的方向输入输出
     *      按照数据类型分类：字节流和字符流
     * 2.复制文件：
     *      1）有源文件
     *      2）有新地址
     *      3）先读取数据
     *      4）读取后直接写入到新地址即可
     *      5）用完以后最好关闭输入输出流
     * 3.缓冲流：和字节流字符流一样：write(int a);write(byte[] a);int a=read()
     * 4.int length=0;
     *      byte[] aa=byte[1000];;1100
     *      while((length=read.read())!=-1){
     *          write(length);
     *           write(aa,0,length);
     *      }
     * 5.如果要读取字符，则用缓存流：
     * String str=read.read();
     * String str=read.readLine();
     * ------------------------------------------
     * 6.反射有三种得到对象的方式？
     * 7.getDeclaredConstructors 无视权限修饰符
     * 8. 调用构造方法
     *    Class<?> aClass1 = Class.forName("reflex.Student");得到类
     *    Constructor<?> constructor = aClass1.getConstructor();得到无参的构造方法
     *    Object o = constructor.newInstance();对无参的构造方法创建对象
     * 9.对于以前的set和get方法，去掉set和get然后将剩余的字符进行小驼峰得到的一个名字叫属性
     * 10.而以前的类下面的变量叫做字段名
     * ---------------------------------------------
     * 反射：得到构造方法，属性，方法
     * 11.得到反射的三种方式？
     * 12.对构造方法的调用getConstructor，创建对象newInstance
     * 13.对字段的取值赋值
     *      Object o = aClass.getConstructor().newInstance();
     *      Field address = aClass.getDeclaredField("address");
     *      address.set(o, "12345");
     *      address.get(o)
     * 14.对方法的调用：
     *     Object o = aClass.getConstructor().newInstance();
     *      Method getAa = aClass.getDeclaredMethod("getAa", String.class);
     *      getAa.setAccessible(true);
     *      getAa.invoke(o,"aaaa");//执行方法
     * 15.setAccessible(true);设置可以强制使用
     * 16.无视Declared权限修饰符
     * 17.枚举 赋值用构造方法
     * 18.枚举没有无参数的构造方法，不允许实例化
     * 19.注解：自定义注解：自己定义的注解
     * 元注解：注解上面的注解
     * 20.测试工具类，1.导jar包，2.创建测试类即可
     * 21.复制多继文件夹，和以前删除文件夹类似，
     *      1.对文件进行复制，
     *      2.对文件夹进行创建
     *      3.递归
     */


}
